COMMENT ⊗   VALID 00026 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00004 00002	\|\\M1BDR30\M2SIGN57\M3NGR25\M4NGR20\M5NGB25\M6SGN114\N
C00006 00003
C00007 00004	\F3
C00011 00005	\F8\CVAL - THE UNIMATION ROBOT CONTROL SYSTEM
C00019 00006	\N
C00023 00007	\F1\CMONITOR COMMANDS:  PROGRAM EDITING
C00027 00008	\N
C00031 00009	\F1\CMONITOR COMMANDS:  POSITION VARIABLE AND PROGRAM LISTING
C00033 00010	\F1\CMONITOR COMMANDS:  PROGRAM AND POSITION DATA STORAGE
C00037 00011	\F1\CMONITOR COMMANDS:  PROGRAM CONTROL
C00047 00012	\F1\CMONITOR COMMANDS:  COMPUTER STATUS AND CONTROL
C00051 00013	\F1\CPROGRAM INSTRUCTION SET
C00058 00014	\!command(REST)
C00063 00015	\F1\CUSER PROGRAM INSTRUCTIONS:  ARM CONFIGURATION CONTROL STATEMENTS
C00066 00016	\F1\CUSER PROGRAM INSTRUCTIONS:  INTEGER VARIABLE AND ASSIGNMENT INSTRUCTIONS
C00069 00017	\!command((SHIFT <trans> BY [<dx>],[<dy>],[<dz>]))
C00070 00018	\F1\CUSER PROGRAM INSTRUCTIONS:  CONTROL STRUCTURES
C00081 00019	\F1\CUSER PROGRAM INSTRUCTIONS:  SPECIAL SWITCH STATEMENTS
C00084 00020	\!command(SPEED <value> [ALWAYS])
C00086 00021	\F1\CUSER PROGRAM INSTRUCTIONS:  MISC. STATEMENTS
C00087 00022	\F1\CEXAMPLE PROGRAM
C00090 00023	\,\F1\CERROR CODES
C00091 00024	\, UN-INCORPORATED NOTES
C00093 00025	\F1\CSUMMARY OF INSTRUCTION SET
C00098 00026	\,	      APPENDIX 1: LOADING INSTRUCTIONS
C00100 ENDMK
C⊗;
\|\\M1BDR30;\M2SIGN57;\M3NGR25;\M4NGR20;\M5NGB25;\M6SGN114;\N
\M7NGB40;\M8BDR40;\N
\⊂'210555;\Nturn on flags outovl option, nest⊃quote, multiarg macros, lf sim,
\←=30;\→S\ε\N Interbase spacing in register S:  single spacing
\N
\N	page numbers and binder indentation
\N\←L\+=50;\→L\;  moving the left margin in to give the binder room
\N\←R\-=50;\→R\;  moving the right margin in to give the binder room
\←L\+=40;\→l\←R\→r \N set up secondary margin
\N
\←=1;\→N\;  This is the starting page number
\∞EVERYPAGE[\N
\oHEAD{1[\DN]}\N This has no section number included
\N\oHEAD{1[V.\DN]}\N This has the section number included.
\←R\→D\2HEAD;\¬D\-=1;\→D\N  This is for right numbering
\N\←L\→D\N This is for left numbering
\WHEAD,D=150;\N
\←N\+=1;\→N]\;
\N
\∞figure[\←N\+=1;\→N]
\N
\8command(a)[\#\F5⊗a⊗\G]\N
\∞col1[\←L\+=50;\→.]\N
\∞col2[\←L\+=600;\→.]\N
\,







\F2\CUSER'S GUIDE TO 


\F6\CV A L\.

\F7
\CA Robot Programming and Control System










\F8\CUnimation, Inc.
\CShelter Rock Lane
\CDanbury, Conn.  06810
\CU.S.A.


\F1\C4\∩th\⊗ Printing - November 1, 1978

\Cc
\F3







\F8\CINTRODUCTION




\F3\JVAL is a system  for programming  all computer controlled  robots
and manipulators.  The VAL system and  language has been developed over  a
period of several years  and is based  on more than  15 years of  computer
controlled manipulator research and development efforts.

VAL is universal.  All instructions and programming  concepts
can be  applied  to  any  manipulator system  capable  of  being  computer
controlled.

VAL is easily learned.  All instructions are clear, concise, and generally
self explanatory.  All commands and communications with the robots or
manipulators are in the English language, and use easily understood word
and number sequences.  Program writing may be done on the same computer
that controls the robot, or on any other computer or computer terminal
capable of storing the instructions in the proper format.

VAL is  easily upgraded.  New  commands and capabilities  are
continually being added to the VAL language.  The system has been designed
to be  easily modified  to suit  specific applications  and to  work  with
manipulators or  robots  of different  configurations  and size.  The  VAL
system can be used with  process controllers and other peripheral  devices
on assembly lines or in manufacturing operations.

VAL programs are universal.   A VAL program written  for one robot may  be
used to operate many different types of robots.

VAL features the ability to  generate libraries of manipulation  routines,
so that  complex  operations  may  be easily  and  quickly  programmed  by
combining pre-defined sub tasks.

VAL operates in real-time.  Continuous, real-time computation permits
complex motions to be quickly executed with efficient use of computer
memory and reduction in overall system complexity.  The VAL system
continuously generates robot control commands, and simultaneously
interacts with a human operator or other interactive controller.  This
permits on-line program generation and modifications.

VAL is self  contained.   The entire  VAL  language,  program
development, and manipulator control system is contained within a  single,
compact, low cost computer/controller unit.

VAL is  easily used.  This  guide  contains most  of  the
information required to  be able to  create robot control  programs and  to
operate a computer controlled robot.\.
\F8\CVAL - THE UNIMATION ROBOT CONTROL SYSTEM


\F3\J\N
Preceding the monitor instructions described below are two symbols which
indicate when each command can be executed.  A period (.) signifies that
the command can be performed when VAL is in its top level monitor mode
and no user program is being executed.  An asterisk (*) indicates that
the command can be performed at the same time that VAL is executing a
user program.  If both symbols are present, then the command can be
always be performed.

For both monitor and program instructions, items enclosed in brackets ([...])
are optional.  Angle brackets (<...>) are used to indicate that the enclosed
item is the name of the actual argument to appear.

When entering any  monitor command  or program  instruction, the  function
name can be typed in full or can be abbreviated to only as many characters
as are necessary to  make the name unique.   Monitor commands and  program
instructions are always terminated by typing a carriage return (RETURN).\.


\F1\CMONITOR COMMANDS:  DEFINING POSITIONS

\F3\J\N
The position and orientation of a manipulator can be stored within the
computer using either a transformation or a precision point.

A transformation is a cartesian description of the position and
orientation of the manipulator's hand.  The hand's X, Y, Z location is
stored as a vector and its orientation is stored as a 3 by 3 matrix.  This
representation is advantageous where relative translations and rotations
are to be performed.  Furthermore, because transformations only refer to
the position and orientation of the hand, they are independent of the
geometry of the manipulator.

Due to the complexity of the computations necessary to convert between
joint angles and cartesian coordinates, using transformations to store the
position and orientation of the manipulator can, at times, be somewhat
inaccurate.  If high precision is required, the manipulator's position and
orientation can be stored as a precision point.  Precision points save the
joint angles of the manipulator and are therefore capable of achieving
full precision playback.  For most instructions requiring a manipulator
position, precision points and transformations can be used
interchangeably.

The names of both precision points and transformations consist of a string
of six characters starting with a letter and followed by any sequence of
letters, numbers,or periods(.).  Precision points and transformations are
distinguished by the fact that precision point names must always be
preceded by the symbol "#".  The number of precision points and
transformations that can be stored in the computer is only limited by the
size of the computer memory.

There are several commands that can be used for defining positions and
determining the current location of the arm:\.


\!command(POINT <position1> [=<position2>]);
\j[ . *] The location  of position 1 is set  equal to that of position  2.
If position 2 is  not specified, the  value of position  1 is either  left
unchanged or set  equal to a  default value if  its value was  previously
undefined. Subsequently, the value of position 1 is printed and any of its
coordinates may  be  modified  by  typing a  new  value  after  the  query
CHANGES?.  Coordinate values must be  separated by commas and values  that
are not to be changed can be omitted.  Changes are continuously asked  for
until no change in the transform is  made.  If the position variable is  a
precision point, its 6 joint  angles are printed.  Otherwise the  position
variable is a transformation and its value is typed as (X,Y,Z,O,A,T).  The
X,Y,Z specify the position of a point centrally located between the finger
tips in  table coordinates.   O,A,T specify  the orientation  of the  hand
(Euler angles).  With all three angles (in degrees) zero, the hand  points
in the negative Y direction with  the fingers in a horizontal plane.   The
orientation vector  which points  from  one finger  tip  to the  other  is
aligned along  the X  axis.  O  specifies a  rotation of  the  orientation
vector about  a vertical  direction.   Thus at  O=90deg, the  hand,  still
horizontal, would point along the positive  X direction.  A is a  rotation
about the  orientation  vector.   With A=90deg,  the  hand  always  points
straight down.  T  is a final  rotation about  the axis of  the wrist  and
corresponds to a rotation of the final (#6) joint.\.


\!command((DPOINT [<position1>],...,[<position8>]));
\jDeletes the values of  up to eight  specified position variables.   This
operation can be used  to recover most of  the memory storage required  by
position variables which are no  longer needed.  Deleted positions  cannot
be listed using any  of the print out  routines and attempts to  reference
these variables within program statements  will generate an error  message
at execution time until their values are re-defined.\.

\,
\N
\!command(HERE <position>); 
\j[ . *] Defines the value of the <position> variable to be equal to
the current arm position.  As with POINT, post modification of the
position coordinates is permitted.\.

\!command(WHERE);
\j[ . *] Prints out the current location of the arm in Euler and joint
angles along with the current hand opening.\.

\!command((BASE [<dX>],[<dY>],[<Z rotation>]));
\j[ . ] Offsets and rotates the location of the base of the manipulator.
Normally when the VAL system is initialized, the base of the arm is
assumed to be located at position {0,0,0} and its orientation such
that in the READY position, the links of the arm are roughly pointed
along the positive Y axis.  If the base is actually located at some other
position {dX,dY,0} and is rotated about the Z axis by an angle
of <Z rotation>, the BASE command can be used to modify the computations
necessary to convert between joint angles and cartesian coordinates to
account for these alterations.\.

\!command((TOOL <tool#> = [<dX>],[<dY>],[<dZ>],[<rZ>]));
\j[ . ]  If  the  dimensions  of <tool#>  are  specified,  the  new  tool
dimensions are set and  the current tool is  set equal to the  specified
dimensions.  If no tool dimensions are given or if dimensions of zero  are
specified, the current  tool is  set equal  to the  dimensions which  were
previously specified  for  <tool#>.   The permitted  tool  numbers  are  0
through 4.  Tool  #0 always  has the dimensions  of the  default tool  and
cannot be altered.  The dimensions  of the current tool are  automatically
taken into  account  whenever  a  conversion from  joint  angles  to  tool
position  or  tool  position  to  joint  angles  is  computed.   The  tool
dimensions alter  where VAL  thinks the  tool  tip is  by first  adding  a
rotation of <rZ> to the last joint of the manipulator and then adding the
offsets of <dX>,<dY>,<dZ>  to the position  of the arm  wrist (the end  of
joint #3) along the x,y,z axes of the tool coordinate system respectively.
This command cannot be executed when the arm is under program  control
or in manual control and operating in WORLD or TOOL coordinates.
To change the tool dimensions under program control use the TOOL command 
described in the user program instructions section.\.


\,
\F1\CMONITOR COMMANDS:  PROGRAM EDITING

\F3\J\N
Distinct sequences  of instructions  to  be executed  are stored  as  user
programs within the computer.  The number of programs that can be saved is
limited only by  the amount  of computer memory  available.  Programs  are
referred to by a name which consists of an arbitrary number of characters.
Like position variables, program names must begin with a letter and can be
followed by any sequence of letters, numbers, or a period.

Each instruction within a program is referred to by a unique step number.
Step numbers are numbered consecutively and are automatically adjusted
whenever instructions are inserted or deleted.  In addition, program steps
can contain step labels.  Step labels are used for program controlled
branching and looping.  Step labels are integer numbers ranging
from 0 to 32767.

Programs can be developed off-line in any computer capable of generating
ASCII text strings or they can be developed using the program
editing routines which are a standard feature of this language.  These
editing routines can be used for both modifying existing programs and
creating new programs.  The editing instructions are explained below.\.


\!command((EDIT [<program>],[<step>]));
\j[ . *] Permits the user to create or modify the <program> starting at step
<step>.  If no step number is specified, editing proceeds from the step
were the last editing session was terminated -1.  If no program is
specified, the last program edited is re-opened.\.


\JOnce having entered the EDIT mode, the following edit functions may
be invoked.\.


\!command(<any program instruction>);
\j[ . *] Replaces the program instruction stored at the current step with the
instruction typed in.  The next step is then displayed for editing.\.

\!command(<carriage return>);
\j[ . *] Typing an empty line (carriage return) leaves the current step
unaltered and displays the next instruction for editing.\.

\!command((C <program>,[<step>]));
\j[ . *] Changes EDITing from the current program to the new user
<program> starting at step <step>. <step> can be
omitted and editing will begin with the first program instruction.\.

\,
\N
\!command(D [<nstep>]);
\j[ . *] Deletes the specified number of instructions starting with the
current instruction step.  If <nstep> is not specified, only the current
step is deleted.\.

\!command(E);
\j[ . *] Exits the EDIT mode and returns to MONITOR mode.\.

\!command(I);
\j[ . *] Moves instructions starting at the current step down one and
inserts in its place any motion instruction that is typed in.  The process
is repeated until an empty line is typed.\.

\!command(L);
\j[ . *] Leaves the current step unaltered and displays the
previous step for editing.\.

\!command(P [<nstep>]);
\j[ . *] Prints the next <nstep> number of program steps and sets the
current line number equal to the last line printed.\.

\!command((R [<arg#>],[<value>]));
\j[ . *] Replaces argument number <arg#> of the current program instruction
with the new value specified by <value>.  If <arg#> is negative, zero, or
omitted, the first argument is replaced.  If <arg#> is greater than the
number of possible arguments, the last argument is changed.  "SETI" instructions
and instructions requiring string arguments cannot be altered using
this EDIT function.\.

\!command(S [<step>]);
\j[ . *] Leaves the current step unaltered and displays the instruction
which is at step <step> in the user program.  If <step> is omitted, the
first instruction of the program is displayed for editing.\.

\!command(T);
\j[ . *] Initiates program teach mode.  In this mode, each time that the
RECORD button on the manual control box is pressed, a MOVEI instruction is
generated which contains as  its arguments, the  current arm position  (in
joint angles),  the  hand  opening,  and the  speed  of  the  motion.   By
successively manually positioning the arm and pressing the RECORD  button,
a complete motion task can be taught.  This mode is terminated by typing a
carriage return on the
console keyboard.\.



\,
\F1\CMONITOR COMMANDS:  POSITION VARIABLE AND PROGRAM LISTING


\F3\J\N
The following commands are used to get hard copies of programs and
position variables.  The execution of these commands can be aborted by
typing a carriage-return (CR) character on the console keyboard.\.

\!command(DIRECTORY);
\j[ . *] Prints out the names of all user programs that have at least one
program step defined.\.

\!command((LISTT [<position1>],...,[<position8>]));
\j[ . *] Types out the values of up to eight selected position variables.
If no position variable names are specified, the locations of all of the 
position variables with defined values will be printed.\.

\!command((LISTP <program>,[<step1>],[<step2>]));
\j[ . *] Types out the user <program> from <step1> to <step2>.
If the step numbers are omitted the entire program will be printed.\.

\,
\F1\CMONITOR COMMANDS:  PROGRAM AND POSITION DATA STORAGE

\F3\J\N
The following commands are used to store and retrieve user programs and
position data on the mini-floppy disk.  The disk is logically divided into
files. Files are referred to by six character names, which must begin with a 
letter (A-Z) followed by any combination of letters and numbers.
In all cases where
an operation may result in destructively writing over valid data which
is contained on the disk, verification is first required before the
operation is performed.  The execution of these commands can be aborted by
typing  carriage-return at any time.\.

\!command(DELETE <file>);
\j[ . *]After requesting confirmation, the specified file is deleted from the disk.\.

\!command(ERASE);
\j[ . *] This routine completely erases the contents of the floppy diskette
and initializes the diskette's file directory information.\.

\!command(FORMAT);
\j[ . *] This command must always  be executed first before a new  diskette
can be  used  for storing  programs  or  data.  It  initializes  the  file
directory and has the effect of  erasing the entire diskette by writing  over
any information that it may contain.\.

\!command(LISTF);
\j[ . *] Types the file directory of the diskette currently loaded in the
mini-floppy disk and prints the amount of space still available for storage.\.

\!command(LOADP <file>);
\j[ . *] Loads the program's contained in <file> into the computer's memory.
If a program already exists which has the same
name as a program contained in the disk file,it will be deleted and replaced by the
program contained on the disk.\.

\!command(LOADT <file>);
\j[ . *] Loads all of the position variables which are contained in the
specified disk file into the computer's memory.  If a position
variable is already defined and a variable with the same name is contained
in the disk file, the position's value will be replaced by the value
read from the disk.\.

\!command((STOREP <file> = [<program1>],...,[<program7>]));
\j[ . *] Stores up to seven specified programs in <file>. If no program names are
given, all existing programs are saved in the specified file.\.

\!command(STORET <file>);
\j[ . *] Stores the names and values of all defined position variables
in the specified floppy disk file.\.
\F1\CMONITOR COMMANDS:  PROGRAM CONTROL

\F3\J\N
The following commands are used for executing and stepping through
user programs.\.

\!command(ABORT);
\j[*] Program execution is terminated at the completion of the step
currently being executed.\.

\!command(DO <program instruction>);
\j[.] The single specified  program instruction is  executed as though  it
were te next step in the  previously executed program.  Thus, this command
can be used for moving the arm (eg.  DO MOVE T1) or altering the  sequence
of program  step  execution (eg.  DO  GOTO  100).  If  no  instruction  is
specified, the previously specified instruction is performed once again.\.

\!command((EXECUTE [<program>],[<nloop>],[<step>]));
\j[ . ] Executes the user <program>, <nloop> number of times.  A loop is
terminated when either a STOP instruction or the last defined step of the
program is encountered.  The value of <nloop> can be between 32767 and
-32768.  Negative values of <nloop> put the program into a continuous
loop.  If <nloop> is omitted or  zero, the program will be
executed one time.  If <program> is omitted, execution of the last user
program EXECUTE'd will be re-initiated.  If <step> is specified, the motion
program begins execution at motion program step <step> for the first pass,
otherwise, the program starts execution at step #1.  All successive passes
begin at the start of the program.\.

\!command((NEXT [<program>],[<nloop>],[<step>]));
\j[ . ] Program single step mode.  If any of the three optional  arguments
are specified,  the program  execution is  initiated in  exactly the  same
manner as an EXEC command.  However,
unlike an EXEC command, program execution is halted immediately after  the
first program  instruction  is  completed.  If  all  three  arguments  are
omitted, the next program instruction is executed and then the program  is
again halted.  As with the PROCEED and RETRY commands, NEXT with no arguments can
only be executed after a PAUSE instruction, a non-fatal run-time error, or
after single step execution of the previous program instruction.\.

\!command(PROCEED);
\j[ . *] Proceeds user program at the step following the step where
execution was halted due to a PAUSE instruction or runtime error.  If a
program is currently running but is in a WAIT loop, waiting for an
external signal to be given, typing PPOCEED has the effect of skipping over the
WAIT instruction.  If a program is executing but is not in a WAIT loop,
this instruction has no effect.\.

\!command(RETRY);
\j[ . ] As with the PROCEED instruction, this command can be used for
restarting program execution after a  runtime error.
In this case, execution resumes at the previous executed instruction
step.  This allows the user to RETRY a step that may have been
aborted.\.

\!command(SPEED <value>);
\j[ .  *] Alters  the speed  at which  all subsequent  program  controlled
manipulator motions are executed.  The speed at which a particular  motion
will execute is approximately related to the product of the speed set  by
this monitor command  and the speed  set by a  program speed  instruction.
The <value> of the  speed can range  from .01 (very  slow) to 327.67  (very
fast) where 100.00 is normal speed.  As an example, if the monitor  speed
command is 50.00 and the program instruction speed is 60.00, the arm  will
move at approximately 30% of its normal speed.\.

\J\N
When a program terminates execution due to a PAUSE or STOP statement or
from any one of a number of runtime errors, an appropriate message will
be typed out followed by one of the
following three phrases: 1) "HALTED AT STEP xxx", 2) "HALTED AT ppp-xxx", or
3) "USER PROGRAM TERMINATED".  The first message is printed when the main
program terminates execution due to an error or a PAUSE statement.  In
this case, "xxx" is the number of the program step following the instruction
that generated the halt.  If a similiar termination takes place but the
halt occurs during the execution of a program subroutine, the subroutine
name is printed (ppp) followed by the subroutine step number.  Finally, if
a STOP instruction is executed or the last defined step of a
program has completed execution, the third phrase is printed.\.
\.
\F1\CMONITOR COMMANDS:  COMPUTER STATUS AND CONTROL

\F3\J\N
There are a number of commands which can be used to determine the current
state of the manipulator computer and to initialize and terminate
execution.  These commands are briefly summarized below.\.

\!command(CALIB);
\j[ . ] This command is used in the Unimate 500 robot system to  calibrate
the joint position sensors.  The arm must be  calibrated whenever the  arm
controller power is  switched on.  Although the  system can  be run  under
manual or program control while  uncalibrated, it is recommended that  the
CALIB instruction be executed as soon after power-up as possible.\.

\!command(DONE);
\j[ . ] MONITOR program stops, computer exits to ODT. The program can be
started by starting execution at location 100000 by typing 100000G. \.

\!command(ENABLE <switch> or DISABLE <switch>);
\j[ . *] These  commands are used  for turning on  and off special  system
hardware features.  At present,  the only switch  defined is "HHT".   This
switch is used for  enabling and disabling the  output of special  control
characters which are  necessary for  the operation of  the Unimation  Hand
Held Terminal.  For terminals other than the HHT, these control characters
will normally not affect the output display.\.

\!command(FREE);
\j[ . *] Types the percentage of available memory that is not currently in use.  As
the available memory is being added up, a simple check of the
whole area is made to ensure that the bookkeeping tags are
consistent.\.

\!command(STATUS);
\j[ . *] Prints the status information of the user program being executed.
This includes data on the program and subroutine step
currently being executed, the speed set by the monitor SPEED command,
and the number of program EXEC loops completed and
still remaining.  Note that if the program is in an infinite EXEC loop,
i.e.  nloop < 0, the print out of the number of loops completed can be off
by 32767*n counts (n=1,2,..,∞), since the loop counter is permitted to
overflow.\.

\!command(ZERO);
\j[ . *] Re-initializes the VAL system and deletes all defined positions
and user programs.  This is a totally destructive operation.  This
function first asks "ARE YOU SURE (Y,N)?" to verify that the operation is
to be performed.\.
\,
\F1\CPROGRAM INSTRUCTION SET

\F3\J\N
The following sections describe the available program instructions.
Because of the great flexibility of the basic structure of the VAL language,
new instructions and data types which are deemed necessary can be easily added.\.

\F1\CUSER PROGRAM INSTRUCTIONS:  MOTION STATEMENTS

\F3\JIn the following motion instructions all distances are in inches, time
is in seconds, and strings can be up to one line
long.\.


\!command(GO   <position> [!]);
\jMoves the arm to the position and orientation specified by the <position>
variable.  There is no path computed for this motion, the hardware position
servo operates in slew mode.  Any changes in configuration requested by
the user are executed during the motion.  If the position name is followed
by an exclamation mark (!), <position> will be set equal to the manipulator's
location at the time the GO instruction is typed.\.

\!command(MOVE <position> [!]);
\jMoves the arm to the position and orientation specified by the <position>
varible.  Intermediate set points between the initial and final arm
position are computed by interpolating the initial and final joint angles.
Any changes in configuration requested by the user are performed during
the motion.  See GO for an explanation of [!].\.

\!command((MOVEI [<jt1>],[<jt2>],[<jt3>],[<jt4>],[<jt5>],[<jt6>],[<hand>],[<speed>]));
\jPerforms the same type of motion as a MOVE instruction, except that the
final arm position is explicitly stated in terms of its six joint angles
and its hand opening instead of a position variable. The specified speed supersedes
any previously executed SPEED program instruction.\.

\!command(MOVES <position> [!]);
\jMoves the arm to the position and orientation specified by the <position>
variable.  The hand is moved along a straight line path and the hand
orientation is smoothly rotated to its final position.  No changes in
configuration are permitted during this motion.  See GO for an explanation
of [!].\.

\!command((DRAW [<dX>],[<dY>],[<dZ>]));
\jMoves the arm along a straight line a distance of dX in the X direction,
dY in the Y direction and dZ in the Z direction.  Any distances omitted
are assumed to be zero.  The arm configuration and orientation are
maintained during this motion.\.

\!command(DEPART <distance>);
\jMoves the hand a distance <distance> along the current axis of
rotation of the last joint.  Negative distances move the hand forward,
positive distances move the hand back.\.

\!command((APPRO <position>[!], <distance>));
\jMoves the hand to the position and orientation specified by
<position>, offset by a distance <distance> along the axis of rotation of the
last joint.  Positive distances move the hand back from the specified
position, negative distances move the hand beyond the position.  See GO
for an explanation of [!].\.

\!command((APPROS <position>[!], <distance>));
\jSame as APPRO, but the hand is moved along a straight line path and the
hand orientation is smoothly rotated to its final position.  No changes in
configuration are permitted during this motion.  See GO for an explanation
of [!].\.

\!command(READY);
\jMoves the arm to the READY position above the work space.  This forces
the arm into a standard configuration.  No matter where the manipulator
is originally positioned, this instruction will always succeed.\.

\,
\!command(REST);
\jMoves the arm to the REST position.  This leaves the arm in a safe
position in case power is turned off.  If no special speed has been set
via the SPEED command, the arm will move to rest at half the normal
speed.\.

\!command(OPEN <distance>   or   CLOSE <distance>);
\jFor 2-state hands  these instructions  are used  without the  <distance>
argument to either OPEN or CLOSE the hand during the execution of the next
motion instruction.  For proportional  hands, these instructions  change
the hand opening  to <distance> inches  during the execution  of the  next
motion instruction.  If <distance> is negative, the hand is closed as  far
as possible, and if <distance> is very large, the hand is opened as far as
possible, otherwise the hand opening is set equal to <distance>.  Both the
OPEN and the CLOSE instructions produce exactly the same effect.\.

\!command(OPENI <distance>   or   CLOSEI <distance>);
\jFor 2-state  hands  these  instructions without  a  <distance>  argument
either open or close the hand immediately. For proportional hands OPENI or
CLOSEI perform the same change in hand opening as an OPEN or CLOSE but the
operation is performed immediately instead of waiting for the next  motion
instruction.\.

\!command((GRASP <distance>,[<label>]));
\jFor proportional hands only, this instruction closes the hand and checks
to see if the final hand opening was less than the specified distance.  If
so, the program branches to the step indicated by the program label or  an
error message is generated if the optional program label is not specified.
This instruction provides a simple one step method for grasping an  object
and testing to ensure that proper contact was achieved.\.

\!command((DRIVE <jt>,<angle>,<time>));
\jOperates the single joint specified by the parameter <jt> (1-7).  The
current joint angle is changed by an amount <angle>.  The change in joint
angle must be specified in degrees.  The duration <time> must be specified
in seconds.\.

\!command(DELAY <duration>);
\jPuts the program in a wait loop for the specified amount of time.  The
duration can be given as any value between .01 and 327.67 seconds.  This
instruction operates just like a "move to nowhere" motion instruction.
In particular if there is a pending hand operation, the hand motion will
take place during the execution of the DELAY instruction and if any
temporary special switches have been specified, they will be cleared after
the conclusion of the DELAY (see section on special switches).\.

\,
\F1\CUSER PROGRAM INSTRUCTIONS:  ARM CONFIGURATION CONTROL STATEMENTS

\F3\J\N
For an anthropomorphic,  six-joint manipulator,  most points  in the  work
space of the arm can be reached by assuming one of eight possible  spatial
configurations.  Normally, the arm  will remain in whatever  configuration
it starts in when  the user program begins  execution or continues from  a
PAUSE statement or runtime error.  The  only exceptions to this rule  are:
1) when the arm is forced to change  from FLIP to NOFLIP or vice versa  in
order to keep joints 4 or 6 within stop limits or 2) when a READY or  REST
instruction is executed or 3) when  a specific change in configuration  is
requested by  the  user  program  through the  execution  of  any  of  the
following program instructions.  When the  user specifies a change in  arm
configuration, the  requested  change  with  be  accomplished  during  the
execution of the next GO, MOVE, or APPRO motion instruction.\.


\!command(RIGHTY or LEFTY);
\jRequests a change in the arm configuration so that the manipulator's
first three joints resemble a human's right or left shouldered arm,
respectively.\.

\!command(ABOVE or BELOW);
\jRequests a change in arm configuration so that the elbow of the arm is
either pointed up or down.\.

\!command(FLIP or NOFLIP);
\jChanges the range of operation of joint 5 to plus (NOFLIP) or minus (FLIP)
angles.\.


\,
\F1\CUSER PROGRAM INSTRUCTIONS:  INTEGER VARIABLE AND ASSIGNMENT INSTRUCTIONS

\F3\J\N
In most cases where an integer variable is required as an argument for a
user program instruction, either the symbolic name of a variable can be
given or an integer value can be specified.  Integer variable names conform
to the syntax given for position variables and program names and their
values must be between 32767 and -32768.  The only time that an integer
value cannot be used in place of a integer variable is when the specified
operation would result in an attempt to alter the value of the constant.
In this case an error message is generated.\.


\!command(SETI <i.var1> = <i.var2> [<operation> <i.var3>]);
\jThe value of <i.var1> is set equal to the result of evaluating
the expression on the right side of the equal sign.  The permitted
<operation>'s are:  addition (+), subtraction (-), multiplication (*),
integer division (/), and modulus determination (%).  If both the operation
and the third variable are missing, the instruction is a direct assignment
statement.\.

\!command(TYPEI <i.var>);
\jTypes the value of the integer variable <i.var>.\.

\!command(HERE <position>);
\jSets the value of the specified position variable equal to the current
manipulator position and orientation.\.

\!command(SET <point1> = <point2>);
\jThe value of point 1 is set equal to the value of
point 2.  If the position and orientation of point 2 
are not yet defined an error message will be generated.\.

\,
\!command((SHIFT <trans> BY [<dx>],[<dy>],[<dz>]));
\jThe X, Y, and Z positions of the transformation <trans> are
modified by adding the changes in distances <dx>, <dy>, and <dz>,
respectively.  If the value of the transformation has not yet been defined
or if its new X, Y, Z position is too large to represent, an error message
will be generated.\.


\,
\F1\CUSER PROGRAM INSTRUCTIONS:  CONTROL STRUCTURES

\F3\J\N
The following instructions are  used to alter the  sequence in which  user
program instructions are  executed and for  interlocking the arm  computer
with other devices. In what follows, <channel> is used to designate one  of
the external signal  input or  output lines.   <channel> can  be either  an
integer number or an integer variable.  The absolute value of <channel> is
used to specify a particular signal line.  The magnitude of <channel> must
be between 1 and N, where N is the number of hardware interlocks  provided
with the system.  For certain instructions, the sign of <channel> is  used
to specify high  and low signal  values.  In these  instances, a  positive
<channel> value indicates a high signal  and a negative value indicates  a
low signal.\.


\!command(GOSUB <prog>);
\jExecution of the current program is temporarily suspended and program
execution continues starting with the first step of the user program
<prog>.  The address of the next step in the current program is
automatically saved and up to 10 programs can be superseded at any given
time.\.

\!command(RETURN [<skip count>]);
\jTerminates execution of the current  user program and resumes  execution
of the last suspended  program. The suspended  program resumes running  at
<skip count>+1 number of steps  following the executed GOSUB  instruction.
Hence, if  the  skip count  is  omitted or  a  count of  0  is  specified,
execution resumes at the instruction following the executed GOSUB.  If the
subroutine started execution due to the triggering of a REACTI  statement,
a skip count  of 1  can be  used to  resume execution  of the  interrupted
routine without re-executing  the interrupted program  step.  Executing  a
RETURN in the main  program produces the same  effect as executing a  STOP
instruction.\.

\!command(IF <i.var1> <relationship> <i.var2> THEN <label>);
\jThe value of <i.var1> is compared to the value of <i.var2> and if
the stated <relationship> is true, the program branches execution to the
program step specified by <label>.  Otherwise, the next sequential step of the
program is executed as usual.  The possible relationships that can be
tested for are: equal (EQ), not equal (NE), greater than (GT), greater
than or equal (GE), less than (LT), and less than or equal (LE).\.

\!command((IFSIG <channel>[,<channel>][,<channel>][,<channel>] THEN <label>));
\jIf the states of the external signals exactly match the specified signal
states, the  program  branches to  the  program instruction  specified  by
<label>.  Otherwise,  if any  mismatch is  detected, the  next  sequential
program step is executed.  The  <channel>s are specified as signed  values
to indicate if each  test is to  be made for a  high or low  signal.  Omitted
channel numbers or channel numbers with a value of zero always satisfy the
matching test.\.

\!command(IGNORE <channel>  [ALWAYS]);
\jDisables the  triggering of  the REACT  or REACTI  instruction which  is
associated with  the  specified external  signal  channel.  If  ALWAYS  is
specified, the reaction  is permanently disabled  until completion of  the
next motion statement.  The value of <channel> must always be greater than
zero.\.

\!command(GOTO <label>);
\jPerforms an unconditional branch to the program step specified by
<label>.\.

\!command(SIGON <channel>);
\jTurns on the signal to the device attached to the specified output channel.
Only positive values of <channel> are permitted.\.

\!command((REACT <channel>,[<program>] [ALWAYS]));
\jThis instruction  initiates the  continuous monitoring  of the  external
signal specified by <channel>.  If a high value  is detected, the  program
reacts by altering the sequence in  which the following program steps  are
executed. The reaction is equivalent to performing a "GOSUB <program>"  at
the completion of  the program step  folllowing the first  occurance of  a
high signal value.
If ALWAYS is specified, the  signal monitoring is active until  either
an IGNORE statement  is executed or  the reaction is  triggered (in  which
case the  equivalent  of an  "IGNORE  <channel> ALWAYS"  is  automatically
performed).  If ALWAYS is omitted, the  signal will only be checked  until
the completiion  of  the next  arm  motion instruction.   If  <program> is
omitted, the program step  following the first occurance  of a high  value
will be  skipped and  execution will  continue at  the following  program
step.  Only one REACT or REACTI command can be associated with any channel
at any given time.\.

\!command((REACTI <channel>,[<program>] [ALWAYS]));
\jLike REACT, this instruction initiates the continuous monitoring of  the
external signal specified  by <channel>.   However, in this  case, when  a
high value is detected, the  current instruction is immediately aborted
and the equivalent of a "GOSUB <program>" is executed. The subroutine call
to <program> is performed such that if a 
"RETURN 0" is used  to exit from <program>,  the
interrupted program step will be executed once again.  In order to  return
control to the interrupted  program and to skip  the furthur execution  of
the interrupted step, a  "RETURN 1" must be  used to exit from  <program>.
If <program> is omitted, when a high signal on <channel> is detected,  the
current program step is immediately  aborted and the next sequential  step
is executed.  The optional argument ALWAYS and the IGNORE instruction have
exactly the same effect  on REACTI as they  do on the REACT  instruction.
Only one REACT or REACTI command can be be associated with any channel  at
any given time.\.

\!command(SIGOFF <channel>);
\jTurns off the signal to the device attached to the specified output channel.
Only positive values of <channel> are permitted.\.

\!command(WAIT <channel>);
\jThe program  is put  into a  wait loop  until the  proper sense  of  the
external signal  specified by  <channel>  is detected.   Positive  channel
numbers indicate  waiting  until the  external  signal goes  true  (high).
Negative channel numbers indicate waiting until the signal is false (low).
A signal wait loop can be aborted by using the monitor PROCEED command.\.

\!command(PAUSE <string>);
\jTerminates execution of a user program and types the message <string>.  Execution
can be continued from this point by typing PROCEED.\.

\!command(STOP);
\jSame as PAUSE except that the program cannot be continued unless
more program loops were specified at the time that program execution was
initiated (see EXECUTE command).\.

\,
\F1\CUSER PROGRAM INSTRUCTIONS:  SPECIAL SWITCH STATEMENTS

\F3\JThe following instructions are used for enabling and disabling special
features of the hardware position servo and the software trajectory
generator.  As indicated below, some of these instructions can be
followed by the word ALWAYS if it is desired that the requested option be
turned off or on during all successive motions.  Whenever a switch is not
followed by ALWAYS, it is assumed that the switch setting is only to
affect the next motion.\.


\!command(COARSE [ALWAYS]);
\jThe low tolerance feature is enabled in the hardware servo so that
larger errors in the final position of the arm joints will be permitted at
the end of the next motion.  This will result in much faster motion
execution times if high accuracy is not required.\.

\!command(FINE [ALWAYS]);
\jOpposite of the COARSE instruction.  This is the default state of the
hardware servo.\.

\!command(NONULL [ALWAYS]);
\jThe next executed motion is terminated without waiting for the electronics
to signal that all moving joints have reached their specified positions.
Like the COARSE command, this mode results in faster motion times if final
position accuracy is not required.  However, since no position error
checking whatsoever is done, motion execution times will be fixed and
final position errors can be quite large.\.

\!command(NULL [ALWAYS]);
\jOpposite of the NONULL instruction.  This is the default state of the
software control system.\.

\!command(INTOFF [ALWAYS]);
\jTurns off the hardware position error integration feature during the
next motion.  However, the hardware integration is always enabled during
the final position error nulling period.\.

\!command(INTON [ALWAYS]);
\jForces the hardware to integrate the position error throughout the next
motion.\.

\,
\!command(SPEED <value> [ALWAYS]);
\jRequests that the next arm motion be performed at a speed other than
normal (=100).  The speed can range from .01 (extremely slow) to
327.67 (extremely fast).\.

\!command((TOOL <tool#> = [<dX>],[<dY>],[<dZ>],[<rZ>]));
\jChanges the  current arm  tool  to <tool#>  and optionally  changes  the
dimensions of <tool#>.  See monitor instruction "TOOL" for a description of the
effect of this instruction.\.


\,

\F1\CUSER PROGRAM INSTRUCTIONS:  MISC. STATEMENTS


\F3\!command(REMARK <string>);
\jComment line, a no-operation at run-time.\.

\!command(TYPE <string>);
\jTypes the message <string> on the console terminal.\.

\F1\CEXAMPLE PROGRAM


\F3\J\N
Writing an example program named DEMO1 to pick up an item at point PICK and place it at
point PLACE.\.


.EDIT DEMO1			User types this in to start editing program DEMO1.
EDITING DEMO1			VAL response

1.	OPEN				Open hand during next motion.
2.	APPRO PICK, 50		Approach to 50 mm away from point PICK.
3.	SPEED 30			Slow down to 30% speed for next move only.
4.	MOVE PICK!			Move to point PICK.  Current arm position is point PICK.
5.	CLOSEI			Close hand now, before next motion.
6.	DEPART 70			Move 70 mm away along hand vector.
7.	APPROS PLACE,75		Move in straight line to 75 mm from point PLACE
8.	SPEED 20			Slow down to 20% speed for next motion only.
9.	MOVES PLACE		Move in straight line to point PLACE.
10.	OPENI 			Open hand before next motion.
11.	DEPART 50			Retract 50 mm. away from point PLACE.
12.	E				Exit from editor, program is completely written.


\F3\J\N
One way of entering the point PLACE.\.

.HERE PLACE			Typing this tells VAL to make the current position of the arm point PLACE.

	
X		Y		Z		O		A		T

300.25	-56.82	105.00	58.44		125.30 	90.00


CHANGES?				VAL asks if operator wishes to make any typed in changes. 
.					A carriage return signifies no changes desired.


Running program DEMO1.	First at 50% speed to see everything is right.

.Speed 50
.EXEC DEMO1,3			Executes DEMO1 3 times at 50% speed.

STATUS				Using background mode to check status while arm is running.
   .	
   .
   .
   .

PROGRAM COMPLETED		VAL says its done ...back to monitor mode.
.SPEED 100				Now run at 100 % speed.
.EXEC ,50				50 times through DEMO1 at 100% speed.



\,\F1\CERROR CODES

\F1\L     Code\cMeaning

\F3\N
1,2,3,4,5,6,7		\jNumber of arm joint out of tolerance or preventing
                        required arm solution.\.

8                       \jDesired position too close.\.

9                       \jDesired position too far out.\.
\, UN-INCORPORATED NOTES

DPOINT 8 POSITIONS
DONT RECOVER EVERYTHING

LABELS RANGE FROM 0 TO 32767.  JUMPS TO UNDEFINED LABELS DONT GENERATE
ERROR MESSAGES UNTIL RUN-TIME WHEN THE BRANCH IS ATTEMPTED.

USING FREE STORAGE RTNS DURING TOUCH UP MODE MAY AT TIMES CAUSE
SLIGHT TIME DELAYS IN THE EXECUTION OF A PROGRAM THAT IS COMPETING
FOR USE OF THE F.S. RTNS.

PROM CHECKSUM

LISTT DOES PRINT UNDEFINED POSITION VARIABLES.

TOOL # = X,Y,Z,Z ROT
;THIS ROUTINES SETS TOOLX, TOOLY, TOOLZ AND TOOLRT FOR USE BY THE A
;SOLUTION ROUTINES.  IF THE DIMENSIONS OF A TOOL ARE SPECIFIED THE NEW
;TOOL DIMENSIONS ARE SAVED AND THE CURRENT TOOL IS SET EQUAL TO THE
;SPECIFIED DIMENSION.  IF DIMENSIONS OF ZERO ARE SPECIFIED FOR THE TOOL
;OR IF NO DIMENSIONS ARE GIVEN, THE CURRENT TOOL IS SWITCHED TO THE
;DIMENSIONS OF THE TOOL WHICH WHERE PREVIOUSLY SPECIFIED.  THE TOOL
;DIMENSIONS ARE AUTOMATICALLY RESET TO THE DEFAULT VALUES ON POWER UP
;AND BY THE "CLEAR" INSTRUCTION.  THE TOOL INSTRUCTION CANNOT BE GIVEN
;WHICH THE ARM IS BEING DRIVEN UNDER MANUAL CONTROL IN EITHER TOOL OR
;WORLD COORDINATES.
;IF TOOL #0 IS SPECIFIED, THE DIMENSION ARGUMENTS AR IGNORED AND
;THE CURRENT TOOL IS SET EQUAL TO THE DIMENSIONS OF THE DEFAULT TOOL.
\F1\CSUMMARY OF INSTRUCTION SET

Monitor Instructions\F5

\!col1;Base [<dX>],[<dY>],[<Z rotation>]\N
\!col2;DIRectory
\!col1;EDit [<program>],[<nstep>]\N
\!col2;DPoint [<position1>],...[<position8>]
\!col1;LISTP <program>,[<step1>],[<step2>]\N
\!col2;Here <position>
\!col1;POint <position1> [=<position2>]\N
\!col2;LISTT [<position1>],...,[<position8>]
\!col1;Tool <tool#> = [<dX>],[<dY>],[<dZ>],[<rZ>]\N
\!col2;Where

\!col1;DElete <file>\N
\!col2;ERase
\!col1;FOrmat\N
\!col2;LISTF
\!col1;LOADP <file>\N
\!col2;LOADT <file>
\!col1;STOREP <file>= [<program1>],...,[<program7>]\N
\!col2;STORET <file>

\!col1;Abort\N
\!col2;CAlib
\!col1;DISable <switch>\N
\!col2;DO <program instruction>
\!col1;DONe\N
\!col2;ENable <switch>
\!col1;EXec [<program>],[<nloop>],[<step>]\N
\!col2;FRee
\!col1;Next [<program>],[<nloop>],[<step>]\N
\!col2;PRoceed
\!col1;Retry\N
\!col2;SPeed <value>
\!col1;STAtus\N
\!col2;Zero

\F1Edit Instructions\F5

\!col1;<any program instruction>\N
\!col2;<carriage return>
\!col1;C <program>,[<nstep>]\N
\!col2;D [<nstep>]
\!col1;E\N
\!col2;I
\!col1;L\N
\!col2;P [<nstep>]
\!col1;R [<arg#>],[<new value>]\N
\!col2;S <step>
\!col1; \N
\!col2;T
\F1User Program Instructions\F5

\!col1;APPRO <position>[!], <dist>\N
\!col2;APPROS <position>[!], <dist>
\!col1;CLOSE <dist>\N
\!col2;CLOSEI <dist>
\!col1;DELay <duration>\N
\!col2;DEPart<distance>
\!col1;DRAw [<dX>],[<dY>],[<dZ>]\N
\!col2;DRIve <jt>,<angle>,<time>
\!col1;GO   <position> [!]\N
\!col2;GRasp <distance>,[<label>]
\!col1;MOVE <position> [!]\N
\!col2;MOVEI [<jt1>],[<jt2>],[<jt3>],[<jt4>],[<jt5>],[<jt6>],[<hand>],[<speed>]
\!col1;MOVES <position> [!]\N
\!col2;OPEN <dist>
\!col1;OPENI <dist>\N
\!col2;REAdy

\!col1;ABove\N
\!col2;BElow
\!col1;FLip\N
\!col2;LEfty
\!col1;NOFlip\N
\!col2;RIghty

\!col1;GOSub <prog>\N
\!col2;GOTo <label>
\!col1;Here <position>\N
\!col2;IF <i.var1> <relationship> <i.var2> THEN <label>
\!col1;IGnore <chan> [ALways]\N
\!col2;IFSig <chan>[,<chan>][,<chan>][,<chan>] THEN <label>
\!col1;PAuse <string>\N
\!col2;REACT <chan> [,<prog>] [ALWAYS]
\!col1;REACTI <chan> [,<prog>] [ALWAYS]\N
\!col2;RETurn <skip count>
\!col1;SET <trans1> = <trans2>\N
\!col2;SETI <i.var1> = <i.var2> [<operation> <i.var3>]
\!col1;SHift <trans> BY [<dx>],[<dy>],[<dz>]\N
\!col2;SIGON <channel>
\!col1;SIGOFF <channel>\N
\!col2;STop
\!col1;TYPEI <i.var>\N
\!col2;Wait <channel>

\!col1;COarse [ALWAYS]\N
\!col2;Fine [ALWAYS]
\!col1;INTOFf [ALWAYS]\N
\!col2;INTON [ALWAYS]
\!col1;NONull [ALWAYS]\N
 !col2;NUll [ALWAYS]
\!col1;SPeed <value> [ALWAYS]\N
\!col2;TOol <tool#> = [<dX>],[<dY>],[<dZ>],[<rZ>]

\!col1;REMark <string>\N
\!col2;TYPE <string>
\,	      APPENDIX 1: LOADING INSTRUCTIONS

The Absolute Loader can be read in using the high speed reader by
manually entering the following Bootstrap Loader in the LSI via ODT
and starting execution at loc = 57744.

LOCATION 	CONTENTS	
  100		   102		CLOCK TRAP
  102		     2		RTI

   R6		  1000		STACK POINTER

57744		 16701		MOV	57776,R1
57746		    26
57750		 12702		MOV	#352,R2
57752		   352
57754		  5211		INC	(R1)
57756		  5711		TST	(R1)
57760		100376		BPL	.-2
57762		116162		MOVB	4(R1),57400(R2)
57764		     4
57766		 57400
57770		  5267		INC	57752
57772		177756
57774		   765		BR	57750
57776		167770		HSR STATUS WORD


After entering the above instructions, the Bootstrap Loader can be
executed by typing:
			57744G

After the paper tape has been read, the compute will halt at
location 57500 indicating that the Absolute Loader has been
properly entered into memory.  The ARM CONTROL PROGRAM can now
be loaded by typing:
			57500G   OR  P

Once loader, the ARM CONTROL PROGRAM can always be restarted by
typing:
			1000G